{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bernoulli Toy Experiment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook reproduces the Bernoulli toy experiment in our paper \"Estimating Gradients for Discrete Random Variables by Sampling without Replacement\". This is a reproduction of the experiment in https://arxiv.org/abs/1810.04777 and the code is adapted from https://github.com/Runjing-Liu120/RaoBlackwellizedSGD/blob/master/experiments/bernoulli_experiments/bernoulli_variances_experiments.ipynb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim \n",
    "\n",
    "from copy import deepcopy\n",
    "\n",
    "import bernoulli_experiments_lib as bern_lib\n",
    "\n",
    "import os\n",
    "import sys\n",
    "\n",
    "import optimization_lib as optim_lib\n",
    "import baselines_lib as bs_lib\n",
    "\n",
    "os.makedirs('plots', exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "softmax = nn.Softmax(dim = 0)\n",
    "\n",
    "sigmoid = nn.Sigmoid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(454)\n",
    "_ = torch.manual_seed(454)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p0:  tensor([0.6000, 0.5100, 0.4800]) \n",
      "\n",
      "sum(p0^2):  tensor(0.8505)\n",
      "sum((1 - p0)^2):  tensor(0.6705) \n",
      "\n",
      "optimal loss:  tensor(0.6705)\n",
      "optimal x:  1\n"
     ]
    }
   ],
   "source": [
    "# fixed parameters\n",
    "d = 3\n",
    "# p0 = torch.rand(d)\n",
    "p0 = torch.Tensor([0.6, 0.51, 0.48])\n",
    "print('p0: ', p0, '\\n')\n",
    "\n",
    "print('sum(p0^2): ', torch.sum(p0**2))\n",
    "print('sum((1 - p0)^2): ', torch.sum((1 - p0)**2), '\\n')\n",
    "\n",
    "# the optima\n",
    "x_optimal = torch.argmin(torch.Tensor([torch.sum(p0**2), torch.sum((1 - p0)**2)]))\n",
    "\n",
    "optimal_loss = torch.min(torch.Tensor([torch.sum(p0**2), torch.sum((1 - p0)**2)]))\n",
    "\n",
    "print('optimal loss: ', optimal_loss)\n",
    "print('optimal x: ', x_optimal.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init phi0:  tensor([0.], requires_grad=True)\n",
      "init e_b:  tensor([0.5000], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "# random init for phi\n",
    "phi0 = torch.Tensor([0.0])\n",
    "phi0.requires_grad_(True)\n",
    "print('init phi0: ', phi0)\n",
    "print('init e_b: ', sigmoid(phi0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# True gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init phi0:  tensor([0.], requires_grad=True)\n",
      "init e_b:  tensor([0.5000], grad_fn=<SigmoidBackward>)\n",
      "tensor([-0.0450])\n"
     ]
    }
   ],
   "source": [
    "# random init for phi\n",
    "phi0 = torch.Tensor([0.0])\n",
    "phi0.requires_grad_(True)\n",
    "print('init phi0: ', phi0)\n",
    "print('init e_b: ', sigmoid(phi0))\n",
    "params = [phi0]\n",
    "optimizer = optim.SGD(params, lr = 1.0)\n",
    "bern_experiment = bern_lib.BernoulliExperiments(p0, d, phi0)\n",
    "bern_experiment.set_var_params(deepcopy(phi0))\n",
    "optimizer.zero_grad()\n",
    "full_loss = bern_experiment.get_full_loss()\n",
    "full_loss.backward()\n",
    "true_grad = deepcopy(bern_experiment.var_params['phi'].grad)\n",
    "print(true_grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Different estimators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we examine the variance of different estimators.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "print(phi0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n",
    "n_samples = 1000\n",
    "\n",
    "def get_gradient_estimators(phi0):\n",
    "    phi0.requires_grad_(True)\n",
    "    params = [phi0]\n",
    "    bern_experiment = bern_lib.BernoulliExperiments(p0, d, phi0)\n",
    "    bern_experiment.set_var_params(deepcopy(phi0))\n",
    "    optbl = bern_experiment.get_full_loss().item()\n",
    "\n",
    "    def get_grad_unordered(k, baseline_constant=None):\n",
    "        return bern_lib.sample_bern_gradient(\n",
    "            phi0, bern_experiment, \n",
    "            topk = 0, \n",
    "            grad_estimator = bs_lib.reinforce_unordered,\n",
    "            n_samples = n_samples,\n",
    "            grad_estimator_kwargs = {\n",
    "                'n_samples': k,\n",
    "                'baseline_constant': baseline_constant\n",
    "            })\n",
    "\n",
    "    def get_grad_unordered_optbl(k):\n",
    "        return get_grad_unordered(k, baseline_constant=optbl)\n",
    "\n",
    "    def get_grad_unordered_nobl(k):\n",
    "        return get_grad_unordered(k, baseline_constant=0.0)\n",
    "    \n",
    "    def get_grad_stratified(k, systematic=False):\n",
    "        return bern_lib.sample_bern_gradient(\n",
    "            phi0, bern_experiment, \n",
    "            topk = 0, \n",
    "            grad_estimator = bs_lib.stratified,\n",
    "            n_samples = n_samples,\n",
    "            grad_estimator_kwargs = {\n",
    "                'n_samples': k,\n",
    "                'systematic': systematic\n",
    "            })\n",
    "    \n",
    "    def get_grad_systematic(k):\n",
    "        return get_grad_stratified(True)\n",
    "    \n",
    "    def get_grad_reinforce_wr(k, baseline_constant=None):\n",
    "        return bern_lib.sample_bern_gradient(\n",
    "            phi0, bern_experiment, \n",
    "            topk = 0, \n",
    "            grad_estimator = bs_lib.reinforce_wr,\n",
    "            n_samples = n_samples,\n",
    "            grad_estimator_kwargs = {\n",
    "                'n_samples': k,\n",
    "                'baseline_constant': baseline_constant\n",
    "            })\n",
    "    \n",
    "    def get_grad_reinforce_wr_optbl(k):\n",
    "        return get_grad_reinforce_wr(k, baseline_constant=optbl)\n",
    "    \n",
    "    def get_grad_reinforce_wr_nobl(k):\n",
    "        return get_grad_reinforce_wr(k, baseline_constant=0.0)\n",
    "\n",
    "    def get_grad_topk(k, sample_topk=False):\n",
    "        return bern_lib.sample_bern_gradient(\n",
    "            phi0, bern_experiment, \n",
    "            topk = k - 1, \n",
    "            sample_topk = sample_topk,\n",
    "            grad_estimator = bs_lib.reinforce,\n",
    "            n_samples = n_samples,\n",
    "            grad_estimator_kwargs={'grad_estimator_kwargs': None})\n",
    "\n",
    "    def get_grad_topk_bl(k, sample_topk=False):\n",
    "        return bern_lib.sample_bern_gradient(\n",
    "            phi0, bern_experiment, \n",
    "            topk = k - 1, \n",
    "            sample_topk = sample_topk,\n",
    "            grad_estimator = bs_lib.reinforce_w_double_sample_baseline,\n",
    "            n_samples = n_samples,\n",
    "            grad_estimator_kwargs={'grad_estimator_kwargs': None})\n",
    "\n",
    "    def get_grad_topk_optbl(k, sample_topk=False):\n",
    "        return bern_lib.sample_bern_gradient(\n",
    "            phi0, bern_experiment, \n",
    "            topk = k - 1, \n",
    "            grad_estimator = bs_lib.reinforce,\n",
    "            n_samples = n_samples,\n",
    "            grad_estimator_kwargs={'grad_estimator_kwargs': None, 'baseline': optbl})\n",
    "\n",
    "    def get_grad_topk_sample(k):\n",
    "        return get_grad_topk(k, sample_topk=True)\n",
    "\n",
    "    def get_grad_topk_bl_sample(k):\n",
    "        return get_grad_topk_bl(k, sample_topk=True)\n",
    "\n",
    "    def get_grad_topk_optbl_sample(k):\n",
    "        return get_grad_topk_optbl(k, sample_topk=True)\n",
    "\n",
    "    alpha = 0.2\n",
    "\n",
    "    xrng = np.arange(2 ** d) + 1\n",
    "    n_eval = xrng\n",
    "    n_eval_double = 2 * xrng\n",
    "    n_eval_optbl = xrng + 2 ** d # Need all evaluations for baseline\n",
    "    \n",
    "    c_vimco = colors[1]\n",
    "    c_detsas = colors[2]\n",
    "    c_stochsas = colors[3]\n",
    "    c_unord = colors[0]\n",
    "    c_stratified = colors[4]\n",
    "    c_systematic = colors[5]\n",
    "    \n",
    "    estimators = [\n",
    "        \n",
    "        (get_grad_stratified, \"Stratified (no bl)\", n_eval, {'color': c_stratified, 'linestyle': '--', 'marker': '.'}),\n",
    "        (get_grad_systematic, \"Systematic (no bl)\", n_eval, {'color': c_systematic, 'linestyle': '--', 'marker': '.'}),\n",
    "        (get_grad_reinforce_wr_nobl, \"VIMCO (no bl)\", n_eval, {'color': c_vimco, 'linestyle': '--', 'marker': '.'}),\n",
    "        (get_grad_topk, \"Det. sum & sample (no bl)\", n_eval, {'color': c_detsas, 'linestyle': '--', 'marker': '.'}),\n",
    "        (get_grad_topk_sample, \"Stoch. sum & sample (no bl)\", n_eval, {'color': c_stochsas, 'linestyle': '--', 'marker': '.'}),\n",
    "        (get_grad_unordered_nobl, \"Unordered (no bl)\", n_eval, {'color': c_unord, 'linestyle': '--', 'marker': '.'}),\n",
    "        \n",
    "        (get_grad_reinforce_wr, \"VIMCO (built-in bl)\", n_eval, {'color': c_vimco, 'linestyle': '-', 'marker': '.'}),\n",
    "        (get_grad_topk_bl, \"Det. sum & sample (sample bl)\", n_eval_double, {'color': c_detsas, 'linestyle': '-', 'marker': '.'}),\n",
    "        (get_grad_topk_bl_sample, \"Stoch. sum & sample (sample bl)\", n_eval_double, {'color': c_stochsas, 'linestyle': '-', 'marker': '.'}),\n",
    "        (get_grad_unordered, \"Unordered (built-in bl)\", n_eval, {'color': c_unord, 'linestyle': '-', 'marker': '.'}),\n",
    "        \n",
    "        # Include these to also show result with 'optimal' baseline\n",
    "#         (get_grad_reinforce_wr_optbl, \"VIMCO (mean bl)\", n_eval_optbl, {'color': c_vimco, 'linestyle': '-', 'marker': '.', 'alpha': alpha}),\n",
    "#         (get_grad_topk_optbl, \"Det. sum & sample (mean bl)\", n_eval_optbl, {'color': c_detsas, 'linestyle': '-', 'marker': '.', 'alpha': alpha}),\n",
    "#         (get_grad_topk_optbl_sample, \"Stoch. sum & sample (mean bl)\", n_eval_optbl, {'color': c_stochsas, 'linestyle': '-', 'marker': '.', 'alpha': alpha}),\n",
    "#         (get_grad_unordered_optbl, \"Unordered (mean bl)\", n_eval_optbl, {'color': c_unord, 'linestyle': '-', 'marker': '.', 'alpha': alpha}),\n",
    "        \n",
    "    ]\n",
    "    return estimators\n",
    "\n",
    "# run for low entropy and high entropy setting\n",
    "phi0 = torch.Tensor([0.0])\n",
    "phi0_hard = torch.Tensor([-4.0])\n",
    "estimators = get_gradient_estimators(phi0)\n",
    "estimators_hard = get_gradient_estimators(phi0_hard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k = 1\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 2\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 3\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 4\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 5\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 6\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 7\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 8\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 1\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 2\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 3\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 4\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 5\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 6\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 7\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n",
      "k = 8\n",
      "Stratified (no bl)\n",
      "Systematic (no bl)\n",
      "VIMCO (no bl)\n",
      "Det. sum & sample (no bl)\n",
      "Stoch. sum & sample (no bl)\n",
      "Unordered (no bl)\n",
      "VIMCO (built-in bl)\n",
      "Det. sum & sample (sample bl)\n",
      "Stoch. sum & sample (sample bl)\n",
      "Unordered (built-in bl)\n"
     ]
    }
   ],
   "source": [
    "def run_experiments(estimators, n_samples):\n",
    "    mixed_grad_array_all = torch.zeros(len(estimators), (2**d), n_samples)\n",
    "\n",
    "    for i in range(2**d):\n",
    "        k = i + 1\n",
    "        print(f\"k = {k}\")\n",
    "\n",
    "        for j, (estimator, name, n_ev, plot_kwargs) in enumerate(estimators):\n",
    "            print(name)\n",
    "            try:\n",
    "                grads = estimator(k)\n",
    "                mixed_grad_array_all[j, i] = grads\n",
    "            except:\n",
    "                raise\n",
    "                print(f\"Warn: {name} with {k} evaluations failed\")\n",
    "    return mixed_grad_array_all\n",
    "mixed_grad_array_all = run_experiments(estimators, n_samples)\n",
    "mixed_grad_array_all_hard = run_experiments(estimators_hard, n_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/pytorch/lib/python3.7/site-packages/ipykernel_launcher.py:6: RuntimeWarning: invalid value encountered in less\n",
      "  \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_results(estimators, mixed_grad_array_all, phi0, ylim=None, inc_baseline=False):\n",
    "\n",
    "    mixed_grad_means = mixed_grad_array_all.mean(-1).numpy()\n",
    "    mixed_grad_stds = mixed_grad_array_all.std(-1).numpy()\n",
    "    \n",
    "    mixed_grad_stds[mixed_grad_stds < 1e-8]  = 0\n",
    "\n",
    "    fig = plt.figure(figsize=(8, 4))\n",
    "    xrng = np.arange(mixed_grad_stds.shape[1]) + 1\n",
    "    estimator_names = []\n",
    "    for grad_arr, (est, name, n_ev, plot_kwargs) in zip(mixed_grad_stds, estimators):\n",
    "        plt.plot(n_ev if inc_baseline else xrng, grad_arr ** 2, **plot_kwargs, lw='2')\n",
    "        estimator_names.append(name)\n",
    "\n",
    "    incl_text = \"incl\" if inc_baseline else \"excl\"\n",
    "    plt.xlabel(f'Number of evaluations ({incl_text}. baseline)')\n",
    "    plt.ylabel('Gradient variance (log scale)')\n",
    "    if ylim is not None:\n",
    "        plt.ylim(ylim)\n",
    "    eta = phi0.detach().numpy()[0]\n",
    "    plt.title('$\\eta$ = {}'.format(eta))\n",
    "    if ylim is None:\n",
    "        plt.legend(estimator_names)\n",
    "    plt.yscale('log')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    # fig.savefig(\"plots/bernoulli_toy_eta{}_{}.pdf\".format(int(eta), \"inc\" if inc_baseline else \"exc\"), format='pdf')\n",
    "\n",
    "inc_baseline=True\n",
    "plot_results(estimators, mixed_grad_array_all, phi0, ylim=None, inc_baseline=inc_baseline)\n",
    "plot_results(estimators_hard, mixed_grad_array_all_hard, phi0_hard, ylim=None, inc_baseline=inc_baseline)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
